package controller;

import java.io.FileNotFoundException;
import java.rmi.RemoteException;
import java.util.List;
import java.util.Vector;
import javax.swing.JOptionPane;

import view.*;
import bean.ClienteVO;
import bean.CondicionDePagoVO;
import bean.IdRodamientoVO;
import bean.OficinaDeVentaVO;
import bean.ProveedorVO;
import bean.RodamientoVO;
import cliente.BDelegate;

public class ControladorVistas {

	private Login vLogin;
	private MainOficina vMainOficina;
	private MainCasaCentral vMainCasaCentral;
	private CargaArchivo vCarga;
	private ABMClientes vABMClientes;
	private ViewArchivo vArchivo;
	private ABMProveedores vABMProveedores;
	private ABMRodamientos vABMRodamientos;
	private Comparativa vComparativa;
	private BDelegate modelo;
	private String tipoCarga;
	private int nroOficina;

	public ControladorVistas(Login vistaLogin) {

		try {
			modelo = new BDelegate();
		} catch (RemoteException e) {
			e.printStackTrace();
		}

		vistaLogin.setControlador(this);
		vLogin = vistaLogin;
		List<OficinaDeVentaVO> oficinasVO = modelo.obtenerOficinas();
		int cant = oficinasVO.size();
		String[] opciones = new String[cant + 2];
		opciones[0] = "---Seleccionar---";
		opciones[1] = "0 - Casa Central";

		for (int i = 0; i < oficinasVO.size(); i++)
			opciones[i + 2] = oficinasVO.get(i).toString();

		vLogin.actualizarListaOficinas(opciones);

	}

	// //////////////////////////////// LOGIN

	public void procesarIngreso(int nro) {

		this.nroOficina = nro - 1;
		vLogin.dispose();
		if (nroOficina < 0)
			return;
		else if (nroOficina == 0) {
			vMainCasaCentral = new MainCasaCentral();
			vMainCasaCentral.setControlador(this);
		} else {
			vMainOficina = new MainOficina(nroOficina);
			vMainOficina.setControlador(this);
		}
	}

	// ////////////////////////////////////// MAIN OFICINA

	public void cargarArchivoCotizacion() {
		tipoCarga = "Cotizacion";
		cargarArchivoVC();
	}

	public void cargarArchivoVenta() {
		tipoCarga = "Venta";
		cargarArchivoVC();
	}

	private void cargarArchivoVC() {
		vCarga = new CargaArchivo(tipoCarga);
		vCarga.setControlador(this);
		vMainOficina.setEnabled(false);

	}

	public void administrarClientes() {
		vABMClientes = new ABMClientes(nroOficina);
		vABMClientes.setControlador(this);
		vMainOficina.setEnabled(false);
		actualizarVistaABMClientes();

	}
	
	public void verComparativa() {
		vComparativa = new Comparativa();
		vComparativa.setControlador(this);
		//vMainOficina.setEnabled(false);
	

	}

	// ////////////////////////////////////// MAIN CPR

	public void cargarArchivoListaDePrecios() {
		tipoCarga = "Lista De Precios";
		cargarArchivoLista();
	}

	private void cargarArchivoLista() {
		vCarga = new CargaArchivo(tipoCarga);
		vCarga.setControlador(this);
		vMainCasaCentral.setEnabled(false);

	}

	public void administrarProveedores() {
		vABMProveedores = new ABMProveedores();
		vABMProveedores.setControlador(this);
		vMainCasaCentral.setEnabled(false);
		actualizarVistaABMProveedores();

	}
	
	public void administrarRodamientos()
	{
		vABMRodamientos = new ABMRodamientos();
		vABMRodamientos.setControlador(this);
		//vMainCasaCentral.setEnabled(false);
		actualizarVistaABMRodamientos();
		
		
	}

	// /////////////////////////////////////////// CARGA ARCHIVO

	public void procesarBuscarArchivo() {

		vCarga.buscarArchivo();
	}

	public void procesarCarga(String s) throws FileNotFoundException {
        String texto = " ";
        
        System.out.println("!!!!!!!!!!!  " + s);
        
		if (tipoCarga.equalsIgnoreCase("Cotizacion")) {
			texto = modelo.solicitarCotizacion(s); 
			vCarga.mostrarMensajeOK();
			vArchivo = new ViewArchivo(texto, "COTIZACION XML");
			vArchivo.setControlador(this);
			vCarga.setEnabled(false);
		}
		if (tipoCarga.equalsIgnoreCase("Venta")) {
			texto = modelo.solicitarVenta(s);
			 vCarga.mostrarMensajeOK(); 
			vArchivo = new ViewArchivo(texto, "REMITO"); 
			vArchivo.setControlador(this);
			vCarga.setEnabled(false);
		}
		if (tipoCarga.equalsIgnoreCase("Lista De Precios")) {
			 modelo.cargarListaDePrecios(s);
			vCarga.mostrarMensajeOK();
		}

	}

	public void salirVCarga(String tipo) {
		if (tipoCarga.equalsIgnoreCase("Cotizacion"))
			vMainOficina.setEnabled(true);
		if (tipoCarga.equalsIgnoreCase("Venta"))
			vMainOficina.setEnabled(true);
		if (tipoCarga.equalsIgnoreCase("Lista De Precios"))
			vMainCasaCentral.setEnabled(true);
		vCarga.dispose();
	}

	// ////////////////////////////////////////////////////////// ABM CLIENTE

	public void agregarCliente(ClienteVO c) {

		if (modelo.buscarCliente(c) != null) {
			int sel = JOptionPane.showConfirmDialog(null,
					"El Cliente ya existe.\n Desea actualizarlo ?",
					"Cliente Existente", JOptionPane.OK_CANCEL_OPTION);
			if (sel != 0)
				return;
			else {
				try {
					modelo.actualizarCliente(c);
				} catch (Exception e) {
					mostrarMensajeErrorActualizar();
					return;
				}
			}
		} else {

			try {
				modelo.guardarCliente(c);
			} catch (Exception e) {
				mostrarMensajeErrorGuardar();
				return;
			}
		}
		actualizarVistaABMClientes();
	}

	public void eliminarCliente(ClienteVO c) {

		try {
			modelo.eliminarCliente(c);
			actualizarVistaABMClientes();
		} catch (Exception e) {
			mostrarMensajeErrorEliminar();
		}
	}

	public void procesarSeleccionCliente(String cuit) {

		ClienteVO aux = new ClienteVO();
		aux.setCuit(cuit);
		ClienteVO c = new ClienteVO();
		try {
			c = modelo.buscarCliente(aux);
		} catch (Exception e) {
			mostrarMensajeErrorBuscar();
		}
		vABMClientes.mostrarAtributosCliente(c);
	}

	public void actualizarVistaABMClientes() {
		OficinaDeVentaVO o = new OficinaDeVentaVO();
		o.setNroOficina(this.nroOficina);
		vABMClientes.actualizarClientes(listarClientes(modelo
				.obtenerClientes(o)));
	}

	private Vector<Object> listarClientes(List<ClienteVO> clientes) {
		Vector<Object> salida = new Vector<Object>();
		for (ClienteVO c : clientes)
			salida.add(c.toVector());
		return salida;
	}

	public void salirABMClientes() {
		vMainOficina.setEnabled(true);
		vABMClientes.dispose();

	}

	// ////////////////////////////////////////////////////////// ABM Proveedor

	public void agregarProveedor(ProveedorVO c) {

		if (modelo.obtenerProveedor(c) != null) {
			int sel = JOptionPane.showConfirmDialog(null,
					"El Proveedor ya existe.\n Desea actualizarlo ?",
					"Proveedor Existente", JOptionPane.OK_CANCEL_OPTION);
			if (sel != 0)
				return;
			else {
				try {
					modelo.actualizarProveedor(c);
				} catch (Exception e) {
					mostrarMensajeErrorActualizar();
					return;
				}
			}
		} else {

			try {
				modelo.guardarProveedor(c);
			} catch (Exception e) {
				mostrarMensajeErrorGuardar();
				return;
			}
		}
		actualizarVistaABMProveedores();
	}

	public void eliminarProveedor(ProveedorVO c) {

		try {
			modelo.eliminarProveedor(c);
			actualizarVistaABMProveedores();
		} catch (Exception e) {
			mostrarMensajeErrorEliminar();
		}
	}

	public void procesarSeleccionProveedor(String cuit) {

		ProveedorVO aux = new ProveedorVO();
		aux.setCuit(cuit);
		ProveedorVO c = new ProveedorVO();
		try {
			c = modelo.obtenerProveedor(aux);
		} catch (Exception e) {
			mostrarMensajeErrorBuscar();
		}
		vABMProveedores.mostrarAtributosProveedor(c);
	}
	
	
	public void actualizarVistaABMProveedores() {
		vABMProveedores.actualizarProveedores(listarProveedores(modelo
				.obtenerProveedores()));
		vABMProveedores.actualizarCondicionesPago(listarCP());
	}

	
	private Vector<Object> listarProveedores(List<ProveedorVO> proveedores) {
		Vector<Object> salida = new Vector<Object>();
		for (ProveedorVO c : proveedores)
			salida.add(c.toVector());
		return salida;
	}
	
	
	private String[] listarCP() {

		List<CondicionDePagoVO> condicionesVO = modelo
				.obtenerListaCondicionesPago();
		int cant = condicionesVO.size();
		String[] condiciones = new String[cant + 1];
		condiciones[0] = "---Seleccionar---";
		for (int i = 0; i < condicionesVO.size(); i++)
			condiciones[i + 1] = condicionesVO.get(i).toString();

		return condiciones;

	}

	public void salirABMProveedores() {
		vMainCasaCentral.setEnabled(true);
		vABMProveedores.dispose();

	}

	private void mostrarMensajeErrorGuardar() {
		JOptionPane.showMessageDialog(null, "No se pudo guardar", "ERROR",
				JOptionPane.ERROR_MESSAGE);
	}

	private void mostrarMensajeErrorActualizar() {
		JOptionPane.showMessageDialog(null, "No se pudo actualizar", "ERROR",
				JOptionPane.ERROR_MESSAGE);
	}

	private void mostrarMensajeErrorEliminar() {
		JOptionPane.showMessageDialog(null, "No se pudo eliminar", "ERROR",
				JOptionPane.ERROR_MESSAGE);
	}

	private void mostrarMensajeErrorBuscar() {
		JOptionPane.showMessageDialog(null,
				"No se encuentra el elemento seleccionado", "ERROR",
				JOptionPane.ERROR_MESSAGE);
	}

	
	// ////////////////////////////////////////////////////////// ABM RODAMIENTO
	
	
	public void agregarRodamiento(RodamientoVO rodamientoVO) 
	{
	
		if (modelo.buscarRodamiento(rodamientoVO) != null) {
			int sel = JOptionPane.showConfirmDialog(null,
					"El Rodamiento ya existe.\n Desea actualizarlo ?",
					"Rodamiento Existente", JOptionPane.OK_CANCEL_OPTION);
			if (sel != 0)
				return;
			else {
				try {
					modelo.actualizarRodamiento(rodamientoVO);
				} catch (Exception e) {
					mostrarMensajeErrorActualizar();
					return;
				}
			}
		} else {

			try {
				modelo.guardarRodamiento(rodamientoVO);
			} catch (Exception e) {
				mostrarMensajeErrorGuardar();
				return;
			}
		}
		actualizarVistaABMRodamientos();
		
	}

	
	private void actualizarVistaABMRodamientos() 
	{		
		vABMRodamientos.actualizarRodamientos(listarRodamientos(modelo.obtenerRodamientos()));	
	}

	
	public void procesarSeleccionRodamiento(IdRodamientoVO idRodamientoVO) 
	{
		RodamientoVO aux = new RodamientoVO();
		aux.setIdRodamiento(idRodamientoVO);
		RodamientoVO c = new RodamientoVO();
		
		try
		{
			c = modelo.obtenerRodamiento(aux);
		}
		catch (Exception e) {
			mostrarMensajeErrorBuscar();		}
		
		vABMRodamientos.mostrarARtibutosRodamiento(c);		
		
	}
	
	private Vector<Object> listarRodamientos(List<RodamientoVO> rodamientos) 
	{
		Vector<Object> salida = new Vector<Object>();
		for (RodamientoVO c : rodamientos)
			salida.add(c.toVector());
		return salida;
	}

//////////////////////////////////////VIEW ARCHIVO
	
	public void salirViewArchivo(){
		vCarga.setEnabled(true);
		vArchivo.dispose();
		
	}
//////////////////////////////////////////// COMPARATIVA
	
	
	public void consultarComparativa(String cod, String car, String marca, String orig){
		
		vComparativa.mostrarConsulta(modelo.obtenerComparativa(cod, car, marca, orig));
		
	}
	
	
	
	
	
}
